
//普通类
/*class MyArray{

    public Object [] arrays = new Object[10];
    //为数组设置值！
    public void setValue(int pos, Object o ){
        arrays[pos] = o;
    }
    public Object getValue(int pos){
        return  arrays[pos];
    }
}*/
//泛型方法
/*
class MyArray {

    //创建一个数组
    public static Object[] arrays = new Object[10];
    //为数组设置值！
    public   static    <E> void setValue(int pos, E o) {   //限定传入的参数类型
        arrays[pos] = o;
    }
    public   <E> Object getValue(int pos) {
        return (E) arrays[pos];                //将返回的数据强制转换成指定的数据类型
    }

}
*/

//泛型类：
class MyArray<E> {

    //创建一个数组
    public Object[] arrays = new Object[10];
    public E[] arrays2 = (E[]) new Object[5];  //也可以这样创建一个数组！！！

    //不能直接实例化E！
    //为数组设置值！
    public void setValue(int pos, E o) {   //限定传入的参数类型
        arrays[pos] = o;
    }

    //
//    public Object getValue(int pos) {
//        return (E) arrays[pos];                //将返回的数据强制转换成指定的数据类型
//    }
//
}
//泛型实现Comparable接口：
    class Alg<E extends Comparable<E>> {

        //下面这个方法报错
        public E max(E[] arrays) {
            E max = arrays[0];
            for (int i = 1; i < arrays.length; i++) {
                //泛型类型的变量不能够直接相互用关系运算符进行比较，因为不能确定是什么类型，
                // 所以需要实现Comparable接口的类——需要添加标记：extends Comparable<E >
                //Object类中并没有实现Comparable接口，所以自定义的类中必须自己去实现Comparable接口！
                // if (max < arrays[i]) {
                if (max.compareTo(arrays[i]) < 0) {
                    max = arrays[i];
                }
            }
            return max;
        }
    }

    class Person {


    }

    public class Test {

        public static void main4(String[] args) {
            //裸类型
            //不加<>,存放不同类型的数据，因为当前JDK兼容了jdk5之前的语法，所以支持了裸类型。


            //擦除机制：
            //在编译阶段将泛型变为Object类型，在运行阶段没有泛型的概念
            //在JVM中没有泛型的概念！


            //泛型的上界：
            //泛型的上届是指：泛型中指定的类型必须是一个类本身或者这个类的子类！


            //泛型类型的变量不能够直接相互用关系运算符进行比较，因为不能确定是什么类型，所以需要实现Comparable接口的类型
            //Object类中并没有实现Comparable接口，所以自定义的类中必须自己去实现Comparable接口！
            //包装类自己已经实现了自动类接口


            //不实现泛型类，而创建泛型方法！！！


        }

        public static void main(String[] args) {
      /*  //泛型类实现Comparable接口：
        Integer [] arrays = {1,5,4,2,3,8,9,6};
   //Integer实现了comparable接口
        Alg<Person> alg = new Alg<>();

        System.out.println(alg.max(arrays));
        //裸类型：*/
            // <>中的内容，不参与类型的组成：
            MyArray<Integer> myArray1 = new MyArray<>();
            MyArray<String> myArray2 = new MyArray<>();
            System.out.println(myArray1);
            System.out.println(myArray2);
        }


        public static void main3(String[] args) {
            //泛型：
            //泛型的使用！
            //1 .我们似乎可以不使用泛型，通过Object类使用一段代码接收所有类型的数据！
     /*   MyArray myArray = new MyArray();
        myArray.setValue(0,10);
        myArray.setValue(1,"hello");
        System.out.println(myArray.getValue(0));
        System.out.println(myArray.getValue(1));*/
            //但是这种一个数组中存储多种不同类型数据的方式太乱，
            // 我们能不能将参数类型进行传参？——泛型
            //2.  通过泛型类使用泛型
     /*   MyArray<Integer> myArray = new MyArray<>();
        myArray.setValue(0,10);
    //    myArray.setValue(1,"zhangsan");//只能传入整型值！
        System.out.println(myArray.getValue(0));*/
            // 3.  使用泛型方法而不是泛型类！
  /*   MyArray myArray = new MyArray();
     myArray.<Integer>setValue(0,5);
        System.out.println(myArray.<Integer>getValue(0));*/
            //3.2 是用静态方法，这样可以不创建对象也可以调用方法！
            //MyArray.<Integer>setValue(0,2);
        }


        public static void main1(String[] args) {
            //包装类：
            //什么是包装类？——包装类可看作是对基本数据类型一种封装
            //装箱，拆箱
            //什么是装箱：
            //装箱是指将基本数据类型的值转换成包装类类型
        /*int a = 10;
        //装箱成Integer类型
        Integer i = Integer.valueOf(a);
        System.out.println(i);
        Integer i2 = 10;    //隐式装箱
        System.out.println(i2);*/
            //下面这种方式好像被弃用了！
            //能否装箱成Double封装类？
     /*   Double double1 = Double.valueOf(a);
        System.out.println(double1);*/
            //   Integer integer = 10;   //也可以直接赋值  ——本质上是调用了valueof的方法！
            //拆箱：
       /* Integer a3 = 10;
        int i1 =  a3.intValue();    //拆箱
        int i2 = a3;                    //自动拆箱
// 观察本质实现，实际上是调用了intValue()方法.
        System.out.println(i1);
        System.out.println(i2);*/
// 一个面试题：
            //背后的原理：
            Integer a4 = 100;
            Integer a5 = 100;
            System.out.println(a4 == a5);
            Integer a6 = 200;
            Integer a7 = 200;
            System.out.println(a6 == a7);
            Integer i = Integer.valueOf(a4);
        }
    }
